// 24_iterator_combos.rs
// Rust 迭代器组合拳教程

fn main() {
    println!("=== Rust 迭代器组合拳 ===\n");
    
    // 第一式：数据红娘 .zip()
    println!("第一式：数据红娘 .zip()");
    let names = vec!["爱丽丝", "鲍勃", "查理"];
    let scores = vec![85, 92, 78];
    
    // 红娘出手，一个顶俩
    let paired: Vec<_> = names.into_iter().zip(scores).collect();
    println!("配对结果: {:?}", paired);
    // 输出: [("爱丽丝", 85), ("鲍勃", 92), ("查理", 78)]
    println!("这位红娘有个原则：只要其中一队没人了，她就立刻收工，绝不加班。\n");
    
    // 第二式：贪吃蛇 .chain()
    println!("第二式：贪吃蛇 .chain()");
    let a = vec![1, 2, 3];
    let b = vec![4, 5];
    
    // 贪吃蛇，启动！
    let all: Vec<_> = a.into_iter().chain(b).collect();
    println!("连接结果: {:?}", all); // 输出: [1, 2, 3, 4, 5]
    println!("它会毫不犹豫地吞下第一个序列，然后把第二个序列紧紧地粘在自己的尾巴上。\n");
    
    // 第三式：降维打击 .flatten()
    println!("第三式：降维打击 .flatten()");
    let nested = vec![vec![1, 2], vec![3, 4], vec![5]];
    
    // 接受来自高维的碾压吧！
    let flat: Vec<_> = nested.into_iter().flatten().collect();
    println!("降维结果: {:?}", flat); // 输出: [1, 2, 3, 4, 5]
    println!("它会无情地碾平所有嵌套，不管你藏得多深，一招抚平。\n");
    
    // 第四式：透视眼 .peekable()
    println!("第四式：透视眼 .peekable()");
    let mut iter = vec![1, 2, 3].into_iter().peekable();
    
    // 我瞅瞅下一个是啥？哦，是1
    if let Some(&val) = iter.peek() {
        println!("我偷看到了下一个值是: {}", val);
    }
    
    // 偷看完，再让他正常出队
    iter.next();
    println!("偷看并出队后，下一个值是: {:?}", iter.next());
    println!("它赋予你预知未来的能力，让你能偷偷瞥一眼队伍里的下一个人，而不打乱队形。\n");
    
    // 第五式：无限月读 .cycle()
    println!("第五式：无限月读 .cycle()");
    let cycle_iter = vec!["A", "B"].into_iter().cycle().take(5);
    
    // "A", "B" 将陷入无限轮回，直到我们喊停
    let cycle_result: Vec<_> = cycle_iter.collect();
    println!("无限月读结果: {:?}", cycle_result); // 输出: ["A", "B", "A", "B", "A"]
    println!("但请务必小心！此招一出，永不停止。你必须用.take()这样的“封印术”来限定它的威力。\n");
    
    // 第六式：管道摄像头 .inspect()
    println!("第六式：管道摄像头 .inspect()");
    let nums = vec![1, 2, 3];
    
    let result: Vec<_> = nums
        .iter()
        .inspect(|x| println!("摄像头拍到原始值: {}", x)) // 安装摄像头
        .map(|x| x * 2)
        .inspect(|x| println!("摄像头拍到乘以2之后: {}", x)) // 再装一个
        .collect();
    
    println!("最终结果: {:?}", result); // 输出: [2, 4, 6]
    println!("它不改变任何数据，只负责忠实地观察和记录，是你调试复杂数据流时的最佳侦探。\n");
    
    // 第七式：影分身之术 .flat_map()
    println!("第七式：影分身之术 .flat_map()");
    let nums = vec![1, 2, 3];
    
    // 对每个数字n，都分身出 n 和 n*10
    let result: Vec<_> = nums.into_iter().flat_map(|n| vec![n, n * 10]).collect();
    println!("影分身结果: {:?}", result); // 输出: [1, 10, 2, 20, 3, 30]
    println!("这是.map()和.flatten()的究极合体技，不仅能对每个元素进行变身，还能让它一次变出好几个分身。\n");
    
    // 终极试炼：打出你的组合拳！
    println!("终极试炼：打出你的组合拳！");
    
    // 1. 创建两个向量
    let ids = vec![1, 2, 3];
    let names = vec!["阿尔法", "贝塔", "伽玛"];
    
    // 2. 用"数据红娘".zip()将它们配对
    // 3. 用"影分身之术".flat_map()对每一对数据，都变幻出两种格式的字符串
    // 4. 最后用"无限月读".cycle()和"封印术".take(6)让结果重复出现
    let combo_result: Vec<_> = ids.into_iter()
        .zip(names)  // 数据红娘配对
        .flat_map(|(id, name)| {  // 影分身之术
            vec![
                format!("{}-{}", id, name),
                format!("{}:{}", name, id)
            ]
        })
        .cycle()  // 无限月读
        .take(9)  // 封印术
        .collect();
    
    println!("组合拳结果: {:?}", combo_result);
    // 输出: ["1-阿尔法", "1:阿尔法", "2-贝塔", "2:贝塔", "3-伽玛", "3:伽玛"]
    
    println!("\n看到了吗？这已经不是简单的代码了，这是一种编程的艺术，一种用链式调用编织出的优雅之舞。");
    println!("当你的同事还在用下标和计数器构建脆弱的循环时，你已经可以用这套组合拳，写出稳健、可读、且极度优雅的代码。");
    println!("从今天起，告别面条式的for循环，拥抱这套组合拳。让你的代码不仅能跑，还能跑得漂亮，跑得让同事投来敬佩的目光！");
}